home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_emacs.idb / usr / freeware / info / gnus-3.z / gnus-3
Encoding:
GNU Info File  |  1998-10-28  |  47.9 KB  |  1,237 lines
  1. This is Info file ../info/gnus, produced by Makeinfo-1.63 from the
  2. input file gnus.texi.
  3.  
  4.    This file documents Gnus, the GNU Emacs newsreader.
  5.  
  6.    Copyright (C) 1995,96 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions.
  20.  
  21. 
  22. File: gnus,  Node: Customizing Threading,  Next: Thread Commands,  Up: Threading
  23.  
  24. Customizing Threading
  25. ---------------------
  26.  
  27. `gnus-show-threads'
  28.      If this variable is `nil', no threading will be done, and all of
  29.      the rest of the variables here will have no effect.  Turning
  30.      threading off will speed group selection up a bit, but it is sure
  31.      to make reading slower and more awkward.
  32.  
  33. `gnus-fetch-old-headers'
  34.      If non-`nil', Gnus will attempt to build old threads by fetching
  35.      more old headers--headers to articles that are marked as read.  If
  36.      you would like to display as few summary lines as possible, but
  37.      still connect as many loose threads as possible, you should set
  38.      this variable to `some' or a number.  If you set it to a number,
  39.      no more than that number of extra old headers will be fetched.  In
  40.      either case, fetching old headers only works if the backend you
  41.      are using carries overview files--this would normally be `nntp',
  42.      `nnspool' and `nnml'.  Also remember that if the root of the
  43.      thread has been expired by the server, there's not much Gnus can
  44.      do about that.
  45.  
  46. `gnus-build-sparse-threads'
  47.      Fetching old headers can be slow.  A low-rent similar effect can be
  48.      gotten by setting this variable to `some'.  Gnus will then look at
  49.      the complete `References' headers of all articles and try to string
  50.      articles that belong in the same thread together.  This will leave
  51.      "gaps" in the threading display where Gnus guesses that an article
  52.      is missing from the thread.  (These gaps appear like normal summary
  53.      lines.  If you select a gap, Gnus will try to fetch the article in
  54.      question.)  If this variable is `t', Gnus will display all these
  55.      "gaps" without regard for whether they are useful for completing
  56.      the thread or not.  Finally, if this variable is `more', Gnus
  57.      won't cut off sparse leaf nodes that don't lead anywhere.  This
  58.      variable is `nil' by default.
  59.  
  60. `gnus-summary-gather-subject-limit'
  61.      Loose threads are gathered by comparing subjects of articles.  If
  62.      this variable is `nil', Gnus requires an exact match between the
  63.      subjects of the loose threads before gathering them into one big
  64.      super-thread.  This might be too strict a requirement, what with
  65.      the presence of stupid newsreaders that chop off long subjects
  66.      lines.  If you think so, set this variable to, say, 20 to require
  67.      that only the first 20 characters of the subjects have to match.
  68.      If you set this variable to a really low number, you'll find that
  69.      Gnus will gather everything in sight into one thread, which isn't
  70.      very helpful.
  71.  
  72.      If you set this variable to the special value `fuzzy', Gnus will
  73.      use a fuzzy string comparison algorithm on the subjects.
  74.  
  75. `gnus-simplify-subject-fuzzy-regexp'
  76.      This can either be a regular expression or list of regular
  77.      expressions that match strings that will be removed from subjects
  78.      if fuzzy subject simplification is used.
  79.  
  80. `gnus-simplify-ignored-prefixes'
  81.      If you set `gnus-summary-gather-subject-limit' to something as low
  82.      as 10, you might consider setting this variable to something
  83.      sensible:
  84.  
  85.           (setq gnus-simplify-ignored-prefixes
  86.                 (concat
  87.                  "\\`\\[?\\("
  88.                  (mapconcat 'identity
  89.                             '("looking"
  90.                                "wanted" "followup" "summary\\( of\\)?"
  91.                                "help" "query" "problem" "question"
  92.                                "answer" "reference" "announce"
  93.                                "How can I" "How to" "Comparison of"
  94.                                ;; ...
  95.                                )
  96.                             "\\|")
  97.                             "\\)\\s *\\("
  98.                             (mapconcat 'identity
  99.                                        '("for" "for reference" "with" "about")
  100.                                        "\\|")
  101.                             "\\)?\\]?:?[ \t]*"))
  102.  
  103.      All words that match this regexp will be removed before comparing
  104.      two subjects.
  105.  
  106. `gnus-summary-gather-exclude-subject'
  107.      Since loose thread gathering is done on subjects only, that might
  108.      lead to many false hits, especially with certain common subjects
  109.      like `' and `(none)'.  To make the situation slightly better, you
  110.      can use the regexp `gnus-summary-gather-exclude-subject' to say
  111.      what subjects should be excluded from the gathering process.  The
  112.      default is `^ *$\\|^(none)$'.
  113.  
  114. `gnus-summary-thread-gathering-function'
  115.      Gnus gathers threads by looking at `Subject' headers.  This means
  116.      that totally unrelated articles may end up in the same "thread",
  117.      which is confusing.  An alternate approach is to look at all the
  118.      `Message-ID's in all the `References' headers to find matches.
  119.      This will ensure that no gathered threads ever includes unrelated
  120.      articles, but it's also means that people who have posted with
  121.      broken newsreaders won't be gathered properly.  The choice is
  122.      yours--plague or cholera:
  123.  
  124.     `gnus-gather-threads-by-subject'
  125.           This function is the default gathering function and looks at
  126.           `Subject's exclusively.
  127.  
  128.     `gnus-gather-threads-by-references'
  129.           This function looks at `References' headers exclusively.
  130.  
  131.      If you want to test gathering by `References', you could say
  132.      something like:
  133.  
  134.           (setq gnus-summary-thread-gathering-function
  135.                 'gnus-gather-threads-by-references)
  136.  
  137. `gnus-summary-make-false-root'
  138.      If non-`nil', Gnus will gather all loose subtrees into one big tree
  139.      and create a dummy root at the top.  (Wait a minute.  Root at the
  140.      top?  Yup.)  Loose subtrees occur when the real root has expired,
  141.      or you've read or killed the root in a previous session.
  142.  
  143.      When there is no real root of a thread, Gnus will have to fudge
  144.      something.  This variable says what fudging method Gnus should use.
  145.      There are four possible values:
  146.  
  147.     `adopt'
  148.           Gnus will make the first of the orphaned articles the parent.
  149.           This parent will adopt all the other articles.  The adopted
  150.           articles will be marked as such by pointy brackets (`<>')
  151.           instead of the standard square brackets (`[]').  This is the
  152.           default method.
  153.  
  154.     `dummy'
  155.           Gnus will create a dummy summary line that will pretend to be
  156.           the parent.  This dummy line does not correspond to any real
  157.           article, so selecting it will just select the first real
  158.           article after the dummy article.
  159.           `gnus-summary-dummy-line-format' is used to specify the
  160.           format of the dummy roots.  It accepts only one format spec:
  161.           `S', which is the subject of the article.  *Note Formatting
  162.           Variables::.
  163.  
  164.     `empty'
  165.           Gnus won't actually make any article the parent, but simply
  166.           leave the subject field of all orphans except the first
  167.           empty.  (Actually, it will use `gnus-summary-same-subject' as
  168.           the subject (*note Summary Buffer Format::.).)
  169.  
  170.     `none'
  171.           Don't make any article parent at all.  Just gather the
  172.           threads and display them after one another.
  173.  
  174.     `nil'
  175.           Don't gather loose threads.
  176.  
  177. `gnus-thread-hide-subtree'
  178.      If non-`nil', all threads will be hidden when the summary buffer is
  179.      generated.
  180.  
  181. `gnus-thread-hide-killed'
  182.      if you kill a thread and this variable is non-`nil', the subtree
  183.      will be hidden.
  184.  
  185. `gnus-thread-ignore-subject'
  186.      Sometimes somebody changes the subject in the middle of a thread.
  187.      If this variable is non-`nil', the subject change is ignored.  If
  188.      it is `nil', which is the default, a change in the subject will
  189.      result in a new thread.
  190.  
  191. `gnus-thread-indent-level'
  192.      This is a number that says how much each sub-thread should be
  193.      indented.  The default is `4'.
  194.  
  195. 
  196. File: gnus,  Node: Thread Commands,  Prev: Customizing Threading,  Up: Threading
  197.  
  198. Thread Commands
  199. ---------------
  200.  
  201. `T k'
  202. `M-C-k'
  203.      Mark all articles in the current sub-thread as read
  204.      (`gnus-summary-kill-thread').  If the prefix argument is positive,
  205.      remove all marks instead.  If the prefix argument is negative, tick
  206.      articles instead.
  207.  
  208. `T l'
  209. `M-C-l'
  210.      Lower the score of the current thread
  211.      (`gnus-summary-lower-thread').
  212.  
  213. `T i'
  214.      Increase the score of the current thread
  215.      (`gnus-summary-raise-thread').
  216.  
  217. `T #'
  218.      Set the process mark on the current thread (`gnus-uu-mark-thread').
  219.  
  220. `T M-#'
  221.      Remove the process mark from the current thread
  222.      (`gnus-uu-unmark-thread').
  223.  
  224. `T T'
  225.      Toggle threading (`gnus-summary-toggle-threads').
  226.  
  227. `T s'
  228.      Expose the thread hidden under the current article, if any
  229.      (`gnus-summary-show-thread').
  230.  
  231. `T h'
  232.      Hide the current (sub)thread (`gnus-summary-hide-thread').
  233.  
  234. `T S'
  235.      Expose all hidden threads (`gnus-summary-show-all-threads').
  236.  
  237. `T H'
  238.      Hide all threads (`gnus-summary-hide-all-threads').
  239.  
  240. `T t'
  241.      Re-thread the thread the current article is part of
  242.      (`gnus-summary-rethread-current').  This works even when the
  243.      summary buffer is otherwise unthreaded.
  244.  
  245. `T ^'
  246.      Make the current article the child of the marked (or previous)
  247.      article (`gnus-summary-reparent-thread'.
  248.  
  249.    The following commands are thread movement commands.  They all
  250. understand the numeric prefix.
  251.  
  252. `T n'
  253.      Go to the next thread (`gnus-summary-next-thread').
  254.  
  255. `T p'
  256.      Go to the previous thread (`gnus-summary-prev-thread').
  257.  
  258. `T d'
  259.      Descend the thread (`gnus-summary-down-thread').
  260.  
  261. `T u'
  262.      Ascend the thread (`gnus-summary-up-thread').
  263.  
  264. `T o'
  265.      Go to the top of the thread (`gnus-summary-top-thread').
  266.  
  267.    If you ignore subject while threading, you'll naturally end up with
  268. threads that have several different subjects in them.  If you then issue
  269. a command like `T k' (`gnus-summary-kill-thread') you might not wish to
  270. kill the entire thread, but just those parts of the thread that have
  271. the same subject as the current article.  If you like this idea, you
  272. can fiddle with `gnus-thread-operation-ignore-subject'.  If is is
  273. non-`nil' (which it is by default), subjects will be ignored when doing
  274. thread commands.  If this variable is `nil', articles in the same
  275. thread with different subjects will not be included in the operation in
  276. question.  If this variable is `fuzzy', only articles that have
  277. subjects that are fuzzily equal will be included.
  278.  
  279. 
  280. File: gnus,  Node: Sorting,  Next: Asynchronous Fetching,  Prev: Threading,  Up: The Summary Buffer
  281.  
  282. Sorting
  283. =======
  284.  
  285.    If you are using a threaded summary display, you can sort the
  286. threads by setting `gnus-thread-sort-functions', which is a list of
  287. functions.  By default, sorting is done on article numbers.  Ready-made
  288. sorting predicate functions include `gnus-thread-sort-by-number',
  289. `gnus-thread-sort-by-author', `gnus-thread-sort-by-subject',
  290. `gnus-thread-sort-by-date', `gnus-thread-sort-by-score', and
  291. `gnus-thread-sort-by-total-score'.
  292.  
  293.    Each function takes two threads and return non-`nil' if the first
  294. thread should be sorted before the other.  Note that sorting really is
  295. normally done by looking only at the roots of each thread.  If you use
  296. more than one function, the primary sort key should be the last function
  297. in the list.  You should probably always include
  298. `gnus-thread-sort-by-number' in the list of sorting
  299. functions--preferably first.  This will ensure that threads that are
  300. equal with respect to the other sort criteria will be displayed in
  301. ascending article order.
  302.  
  303.    If you would like to sort by score, then by subject, and finally by
  304. number, you could do something like:
  305.  
  306.      (setq gnus-thread-sort-functions
  307.            '(gnus-thread-sort-by-number
  308.              gnus-thread-sort-by-subject
  309.              gnus-thread-sort-by-score))
  310.  
  311.    The threads that have highest score will be displayed first in the
  312. summary buffer.  When threads have the same score, they will be sorted
  313. alphabetically.  The threads that have the same score and the same
  314. subject will be sorted by number, which is (normally) the sequence in
  315. which the articles arrived.
  316.  
  317.    If you want to sort by score and then reverse arrival order, you
  318. could say something like:
  319.  
  320.      (setq gnus-thread-sort-functions
  321.            '((lambda (t1 t2)
  322.                (not (gnus-thread-sort-by-number t1 t2)))
  323.              gnus-thread-sort-by-score))
  324.  
  325.    The function in the `gnus-thread-score-function' variable (default
  326. `+') is used for calculating the total score of a thread.  Useful
  327. functions might be `max', `min', or squared means, or whatever tickles
  328. your fancy.
  329.  
  330.    If you are using an unthreaded display for some strange reason or
  331. other, you have to fiddle with the `gnus-article-sort-functions'
  332. variable.  It is very similar to the `gnus-thread-sort-functions',
  333. except that is uses slightly different functions for article
  334. comparison.  Available sorting predicate functions are
  335. `gnus-article-sort-by-number', `gnus-article-sort-by-author',
  336. `gnus-article-sort-by-subject', `gnus-article-sort-by-date', and
  337. `gnus-article-sort-by-score'.
  338.  
  339.    If you want to sort an unthreaded summary display by subject, you
  340. could say something like:
  341.  
  342.      (setq gnus-article-sort-functions
  343.            '(gnus-article-sort-by-number
  344.              gnus-article-sort-by-subject))
  345.  
  346. 
  347. File: gnus,  Node: Asynchronous Fetching,  Next: Article Caching,  Prev: Sorting,  Up: The Summary Buffer
  348.  
  349. Asynchronous Article Fetching
  350. =============================
  351.  
  352.    If you read your news from an NNTP server that's far away, the
  353. network latencies may make reading articles a chore.  You have to wait
  354. for a while after pressing `n' to go to the next article before the
  355. article appears.  Why can't Gnus just go ahead and fetch the article
  356. while you are reading the previous one? Why not, indeed.
  357.  
  358.    First, some caveats.  There are some pitfalls to using asynchronous
  359. article fetching, especially the way Gnus does it.
  360.  
  361.    Let's say you are reading article 1, which is short, and article 2 is
  362. quite long, and you are not interested in reading that.  Gnus does not
  363. know this, so it goes ahead and fetches article 2.  You decide to read
  364. article 3, but since Gnus is in the process of fetching article 2, the
  365. connection is blocked.
  366.  
  367.    To avoid these situations, Gnus will open two (count 'em two)
  368. connections to the server.  Some people may think this isn't a very nice
  369. thing to do, but I don't see any real alternatives.  Setting up that
  370. extra connection takes some time, so Gnus startup will be slower.
  371.  
  372.    Gnus will fetch more articles than you will read.  This will mean
  373. that the link between your machine and the NNTP server will become more
  374. loaded than if you didn't use article pre-fetch.  The server itself will
  375. also become more loaded--both with the extra article requests, and the
  376. extra connection.
  377.  
  378.    Ok, so now you know that you shouldn't really use this thing...
  379. unless you really want to.
  380.  
  381.    Here's how:  Set `gnus-asynchronous' to `t'.  The rest should happen
  382. automatically.
  383.  
  384.    You can control how many articles that are to be pre-fetched by
  385. setting `nntp-async-number'.  This is five by default, which means that
  386. when you read an article in the group, `nntp' will pre-fetch the next
  387. five articles.  If this variable is `t', `nntp' will pre-fetch all the
  388. articles that it can without bound.  If it is `nil', no pre-fetching
  389. will be made.
  390.  
  391.    You may wish to create some sort of scheme for choosing which
  392. articles that `nntp' should consider as candidates for pre-fetching.
  393. For instance, you may wish to pre-fetch all articles with high scores,
  394. and not pre-fetch low-scored articles.  You can do that by setting the
  395. `gnus-asynchronous-article-function', which will be called with an
  396. alist where the keys are the article numbers.  Your function should
  397. return an alist where the articles you are not interested in have been
  398. removed.  You could also do sorting on article score and the like.
  399.  
  400. 
  401. File: gnus,  Node: Article Caching,  Next: Persistent Articles,  Prev: Asynchronous Fetching,  Up: The Summary Buffer
  402.  
  403. Article Caching
  404. ===============
  405.  
  406.    If you have an *extremely* slow NNTP connection, you may consider
  407. turning article caching on.  Each article will then be stored locally
  408. under your home directory.  As you may surmise, this could potentially
  409. use *huge* amounts of disk space, as well as eat up all your inodes so
  410. fast it will make your head swim.  In vodka.
  411.  
  412.    Used carefully, though, it could be just an easier way to save
  413. articles.
  414.  
  415.    To turn caching on, set `gnus-use-cache' to `t'.  By default, all
  416. articles that are ticked or marked as dormant will then be copied over
  417. to your local cache (`gnus-cache-directory').  Whether this cache is
  418. flat or hierarchal is controlled by the `gnus-use-long-file-name'
  419. variable, as usual.
  420.  
  421.    When re-select a ticked or dormant article, it will be fetched from
  422. the cache instead of from the server.  As articles in your cache will
  423. never expire, this might serve as a method of saving articles while
  424. still keeping them where they belong.  Just mark all articles you want
  425. to save as dormant, and don't worry.
  426.  
  427.    When an article is marked as read, is it removed from the cache.
  428.  
  429.    The entering/removal of articles from the cache is controlled by the
  430. `gnus-cache-enter-articles' and `gnus-cache-remove-articles' variables.
  431. Both are lists of symbols.  The first is `(ticked dormant)' by
  432. default, meaning that ticked and dormant articles will be put in the
  433. cache.  The latter is `(read)' by default, meaning that articles that
  434. are marked as read are removed from the cache.  Possibly symbols in
  435. these two lists are `ticked', `dormant', `unread' and `read'.
  436.  
  437.    So where does the massive article-fetching and storing come into the
  438. picture?  The `gnus-jog-cache' command will go through all subscribed
  439. newsgroups, request all unread articles, and store them in the cache.
  440. You should only ever, ever ever ever, use this command if 1) your
  441. connection to the NNTP server is really, really, really slow and 2) you
  442. have a really, really, really huge disk.  Seriously.
  443.  
  444.    It is likely that you do not want caching on some groups.  For
  445. instance, if your `nnml' mail is located under your home directory, it
  446. makes no sense to cache it somewhere else under your home directory.
  447. Unless you feel that it's neat to use twice as much space.  To limit
  448. the caching, you could set the `gnus-uncacheable-groups' regexp to
  449. `^nnml', for instance.  This variable is `nil' by default.
  450.  
  451.    The cache stores information on what articles it contains in its
  452. active file (`gnus-cache-active-file').  If this file (or any other
  453. parts of the cache) becomes all messed up for some reason or other, Gnus
  454. offers two functions that will try to set things right.  `M-x
  455. gnus-cache-generate-nov-databases' will (re)build all the NOV files,
  456. and `gnus-cache-generate-active' will (re)generate the active file.
  457.  
  458. 
  459. File: gnus,  Node: Persistent Articles,  Next: Article Backlog,  Prev: Article Caching,  Up: The Summary Buffer
  460.  
  461. Persistent Articles
  462. ===================
  463.  
  464.    Closely related to article caching, we have "persistent articles".
  465. In fact, it's just a different way of looking at caching, and much more
  466. useful in my opinion.
  467.  
  468.    Say you're reading a newsgroup, and you happen on to some valuable
  469. gem that you want to keep and treasure forever.  You'd normally just
  470. save it (using one of the many saving commands) in some file.  The
  471. problem with that is that it's just, well, yucky.  Ideally you'd prefer
  472. just having the article remain in the group where you found it forever;
  473. untouched by the expiry going on at the news server.
  474.  
  475.    This is what a "persistent article" is--an article that just won't
  476. be deleted.  It's implemented using the normal cache functions, but you
  477. use two explicit commands for managing persistent articles:
  478.  
  479. `*'
  480.      Make the current article persistent (`gnus-cache-enter-article').
  481.  
  482. `M-*'
  483.      Remove the current article from the persistent articles
  484.      (`gnus-cache-remove-article').  This will normally delete the
  485.      article.
  486.  
  487.    Both these commands understand the process/prefix convention.
  488.  
  489.    To avoid having all ticked articles (and stuff) entered into the
  490. cache, you should set `gnus-use-cache' to `passive' if you're just
  491. interested in persistent articles:
  492.  
  493.      (setq gnus-use-cache 'passive)
  494.  
  495. 
  496. File: gnus,  Node: Article Backlog,  Next: Saving Articles,  Prev: Persistent Articles,  Up: The Summary Buffer
  497.  
  498. Article Backlog
  499. ===============
  500.  
  501.    If you have a slow connection, but the idea of using caching seems
  502. unappealing to you (and it is, really), you can help the situation some
  503. by switching on the "backlog".  This is where Gnus will buffer already
  504. read articles so that it doesn't have to re-fetch articles you've
  505. already read.  This only helps if you are in the habit of re-selecting
  506. articles you've recently read, of course.  If you never do that,
  507. turning the backlog on will slow Gnus down a little bit, and increase
  508. memory usage some.
  509.  
  510.    If you set `gnus-keep-backlog' to a number N, Gnus will store at
  511. most N old articles in a buffer for later re-fetching.  If this
  512. variable is non-`nil' and is not a number, Gnus will store *all* read
  513. articles, which means that your Emacs will grow without bound before
  514. exploding and taking your machine down with you.  I put that in there
  515. just to keep y'all on your toes.
  516.  
  517.    This variable is `nil' by default.
  518.  
  519. 
  520. File: gnus,  Node: Saving Articles,  Next: Decoding Articles,  Prev: Article Backlog,  Up: The Summary Buffer
  521.  
  522. Saving Articles
  523. ===============
  524.  
  525.    Gnus can save articles in a number of ways.  Below is the
  526. documentation for saving articles in a fairly straight-forward fashion
  527. (i.e., little processing of the article is done before it is saved).
  528. For a different approach (uudecoding, unsharing) you should use
  529. `gnus-uu' (*note Decoding Articles::.).
  530.  
  531.    If `gnus-save-all-headers' is non-`nil', Gnus will not delete
  532. unwanted headers before saving the article.
  533.  
  534.    If the preceding variable is `nil', all headers that match the
  535. `gnus-saved-headers' regexp will be kept, while the rest will be
  536. deleted before saving.
  537.  
  538. `O o'
  539. `o'
  540.      Save the current article using the default article saver
  541.      (`gnus-summary-save-article').
  542.  
  543. `O m'
  544.      Save the current article in mail format
  545.      (`gnus-summary-save-article-mail').
  546.  
  547. `O r'
  548.      Save the current article in rmail format
  549.      (`gnus-summary-save-article-rmail').
  550.  
  551. `O f'
  552.      Save the current article in plain file format
  553.      (`gnus-summary-save-article-file').
  554.  
  555. `O b'
  556.      Save the current article body in plain file format
  557.      (`gnus-summary-save-article-body-file').
  558.  
  559. `O h'
  560.      Save the current article in mh folder format
  561.      (`gnus-summary-save-article-folder').
  562.  
  563. `O v'
  564.      Save the current article in a VM folder
  565.      (`gnus-summary-save-article-vm').
  566.  
  567. `O p'
  568.      Save the current article in a pipe.  Uhm, like, what I mean
  569.      is--Pipe the current article to a process
  570.      (`gnus-summary-pipe-output').
  571.  
  572.    All these commands use the process/prefix convention (*note
  573. Process/Prefix::.).  If you save bunches of articles using these
  574. functions, you might get tired of being prompted for files to save each
  575. and every article in.  The prompting action is controlled by the
  576. `gnus-prompt-before-saving' variable, which is `always' by default,
  577. giving you that excessive prompting action you know and loathe.  If you
  578. set this variable to `t' instead, you'll be prompted just once for each
  579. series of articles you save.  If you like to really have Gnus do all
  580. your thinking for you, you can even set this variable to `nil', which
  581. means that you will never be prompted for files to save articles in.
  582. Gnus will simply save all the articles in the default files.
  583.  
  584.    You can customize the `gnus-default-article-saver' variable to make
  585. Gnus do what you want it to.  You can use any of the four ready-made
  586. functions below, or you can create your own.
  587.  
  588. `gnus-summary-save-in-rmail'
  589.      This is the default format, "babyl".  Uses the function in the
  590.      `gnus-rmail-save-name' variable to get a file name to save the
  591.      article in.  The default is `gnus-plain-save-name'.
  592.  
  593. `gnus-summary-save-in-mail'
  594.      Save in a Unix mail (mbox) file.  Uses the function in the
  595.      `gnus-mail-save-name' variable to get a file name to save the
  596.      article in.  The default is `gnus-plain-save-name'.
  597.  
  598. `gnus-summary-save-in-file'
  599.      Append the article straight to an ordinary file.  Uses the
  600.      function in the `gnus-file-save-name' variable to get a file name
  601.      to save the article in.  The default is `gnus-numeric-save-name'.
  602.  
  603. `gnus-summary-save-body-in-file'
  604.      Append the article body to an ordinary file.  Uses the function in
  605.      the `gnus-file-save-name' variable to get a file name to save the
  606.      article in.  The default is `gnus-numeric-save-name'.
  607.  
  608. `gnus-summary-save-in-folder'
  609.      Save the article to an MH folder using `rcvstore' from the MH
  610.      library.  Uses the function in the `gnus-folder-save-name' variable
  611.      to get a file name to save the article in.  The default is
  612.      `gnus-folder-save-name', but you can also use
  613.      `gnus-Folder-save-name'.  The former creates capitalized names, and
  614.      the latter does not.
  615.  
  616. `gnus-summary-save-in-vm'
  617.      Save the article in a VM folder.  You have to have the VM mail
  618.      reader to use this setting.
  619.  
  620.    All of these functions, except for the last one, will save the
  621. article in the `gnus-article-save-directory', which is initialized from
  622. the `SAVEDIR' environment variable.  This is `~/News/' by default.
  623.  
  624.    As you can see above, the functions use different functions to find a
  625. suitable name of a file to save the article in.  Below is a list of
  626. available functions that generate names:
  627.  
  628. `gnus-Numeric-save-name'
  629.      Generates file names that look like `~/News/Alt.andrea-dworkin/45'.
  630.  
  631. `gnus-numeric-save-name'
  632.      Generates file names that look like `~/News/alt.andrea-dworkin/45'.
  633.  
  634. `gnus-Plain-save-name'
  635.      Generates file names that look like `~/News/Alt.andrea-dworkin'.
  636.  
  637. `gnus-plain-save-name'
  638.      Generates file names that look like `~/News/alt.andrea-dworkin'.
  639.  
  640.    You can have Gnus suggest where to save articles by plonking a
  641. regexp into the `gnus-split-methods' alist.  For instance, if you would
  642. like to save articles related to Gnus in the file `gnus-stuff', and
  643. articles related to VM in `vm-stuff', you could set this variable to
  644. something like:
  645.  
  646.      (("^Subject:.*gnus\\|^Newsgroups:.*gnus" "gnus-stuff")
  647.       ("^Subject:.*vm\\|^Xref:.*vm" "vm-stuff")
  648.       (my-choosing-function "../other-dir/my-stuff")
  649.       ((equal gnus-newsgroup-name "mail.misc") "mail-stuff"))
  650.  
  651.    We see that this is a list where each element is a list that has two
  652. elements--the "match" and the "file".  The match can either be a string
  653. (in which case it is used as a regexp to match on the article head); it
  654. can be a symbol (which will be called as a function with the group name
  655. as a parameter); or it can be a list (which will be `eval'ed).  If any
  656. of these actions have a non-`nil' result, the "file" will be used as a
  657. default prompt.  In addition, the result of the operation itself will
  658. be used if the function or form called returns a string or a list of
  659. strings.
  660.  
  661.    You basically end up with a list of file names that might be used
  662. when saving the current article.  (All "matches" will be used.)  You
  663. will then be prompted for what you really want to use as a name, with
  664. file name completion over the results from applying this variable.
  665.  
  666.    This variable is `((gnus-article-archive-name))' by default, which
  667. means that Gnus will look at the articles it saves for an
  668. `Archive-name' line and use that as a suggestion for the file name.
  669.  
  670.    Finally, you have the `gnus-use-long-file-name' variable.  If it is
  671. `nil', all the preceding functions will replace all periods (`.') in
  672. the group names with slashes (`/')--which means that the functions will
  673. generate hierarchies of directories instead of having all the files in
  674. the toplevel directory (`~/News/alt/andrea-dworkin' instead of
  675. `~/News/alt.andrea-dworkin'.)  This variable is `t' by default on most
  676. systems.  However, for historical reasons, this is `nil' on Xenix and
  677. usg-unix-v machines by default.
  678.  
  679.    This function also affects kill and score file names.  If this
  680. variable is a list, and the list contains the element `not-score', long
  681. file names will not be used for score files, if it contains the element
  682. `not-save', long file names will not be used for saving, and if it
  683. contains the element `not-kill', long file names will not be used for
  684. kill files.
  685.  
  686.    If you'd like to save articles in a hierarchy that looks something
  687. like a spool, you could
  688.  
  689.      (setq gnus-use-long-file-name '(not-save)) ; to get a hierarchy
  690.      (setq gnus-default-article-save 'gnus-summary-save-in-file) ; no encoding
  691.  
  692.    Then just save with `o'.  You'd then read this hierarchy with
  693. ephemeral `nneething' groups--`G D' in the group buffer, and the
  694. toplevel directory as the argument (`~/News/').  Then just walk around
  695. to the groups/directories with `nneething'.
  696.  
  697. 
  698. File: gnus,  Node: Decoding Articles,  Next: Article Treatment,  Prev: Saving Articles,  Up: The Summary Buffer
  699.  
  700. Decoding Articles
  701. =================
  702.  
  703.    Sometime users post articles (or series of articles) that have been
  704. encoded in some way or other.  Gnus can decode them for you.
  705.  
  706. * Menu:
  707.  
  708. * Uuencoded Articles::    Uudecode articles.
  709. * Shared Articles::       Unshar articles.
  710. * PostScript Files::      Split PostScript.
  711. * Decoding Variables::    Variables for a happy decoding.
  712. * Viewing Files::         You want to look at the result of the decoding?
  713.  
  714.    All these functions use the process/prefix convention (*note
  715. Process/Prefix::.) for finding out what articles to work on, with the
  716. extension that a "single article" means "a single series".  Gnus can
  717. find out by itself what articles belong to a series, decode all the
  718. articles and unpack/view/save the resulting file(s).
  719.  
  720.    Gnus guesses what articles are in the series according to the
  721. following simplish rule: The subjects must be (nearly) identical,
  722. except for the last two numbers of the line.  (Spaces are largely
  723. ignored, however.)
  724.  
  725.    For example: If you choose a subject called `cat.gif (2/3)', Gnus
  726. will find all the articles that match the regexp `^cat.gif
  727. ([0-9]+/[0-9]+).*$'.
  728.  
  729.    Subjects that are nonstandard, like `cat.gif (2/3) Part 6 of a
  730. series', will not be properly recognized by any of the automatic viewing
  731. commands, and you have to mark the articles manually with `#'.
  732.  
  733. 
  734. File: gnus,  Node: Uuencoded Articles,  Next: Shared Articles,  Up: Decoding Articles
  735.  
  736. Uuencoded Articles
  737. ------------------
  738.  
  739. `X u'
  740.      Uudecodes the current series (`gnus-uu-decode-uu').
  741.  
  742. `X U'
  743.      Uudecodes and saves the current series
  744.      (`gnus-uu-decode-uu-and-save').
  745.  
  746. `X v u'
  747.      Uudecodes and views the current series (`gnus-uu-decode-uu-view').
  748.  
  749. `X v U'
  750.      Uudecodes, views and saves the current series
  751.      (`gnus-uu-decode-uu-and-save-view').
  752.  
  753.    Remember that these all react to the presence of articles marked with
  754. the process mark.  If, for instance, you'd like to decode and save an
  755. entire newsgroup, you'd typically do `M P a' (`gnus-uu-mark-all') and
  756. then `X U' (`gnus-uu-decode-uu-and-save').
  757.  
  758.    All this is very much different from how `gnus-uu' worked with GNUS
  759. 4.1, where you had explicit keystrokes for everything under the sun.
  760. This version of `gnus-uu' generally assumes that you mark articles in
  761. some way (*note Setting Process Marks::.) and then press `X u'.
  762.  
  763.    Note: When trying to decode articles that have names matching
  764. `gnus-uu-notify-files', which is hard-coded to
  765. `[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)', `gnus-uu' will
  766. automatically post an article on `comp.unix.wizards' saying that you
  767. have just viewed the file in question.  This feature can't be turned
  768. off.
  769.  
  770. 
  771. File: gnus,  Node: Shared Articles,  Next: PostScript Files,  Prev: Uuencoded Articles,  Up: Decoding Articles
  772.  
  773. Shared Articles
  774. ---------------
  775.  
  776. `X s'
  777.      Unshars the current series (`gnus-uu-decode-unshar').
  778.  
  779. `X S'
  780.      Unshars and saves the current series
  781.      (`gnus-uu-decode-unshar-and-save').
  782.  
  783. `X v s'
  784.      Unshars and views the current series
  785.      (`gnus-uu-decode-unshar-view').
  786.  
  787. `X v S'
  788.      Unshars, views and saves the current series
  789.      (`gnus-uu-decode-unshar-and-save-view').
  790.  
  791. 
  792. File: gnus,  Node: PostScript Files,  Next: Decoding Variables,  Prev: Shared Articles,  Up: Decoding Articles
  793.  
  794. PostScript Files
  795. ----------------
  796.  
  797. `X p'
  798.      Unpack the current PostScript series (`gnus-uu-decode-postscript').
  799.  
  800. `X P'
  801.      Unpack and save the current PostScript series
  802.      (`gnus-uu-decode-postscript-and-save').
  803.  
  804. `X v p'
  805.      View the current PostScript series
  806.      (`gnus-uu-decode-postscript-view').
  807.  
  808. `X v P'
  809.      View and save the current PostScript series
  810.      (`gnus-uu-decode-postscript-and-save-view').
  811.  
  812. 
  813. File: gnus,  Node: Decoding Variables,  Next: Viewing Files,  Prev: PostScript Files,  Up: Decoding Articles
  814.  
  815. Decoding Variables
  816. ------------------
  817.  
  818.    Adjective, not verb.
  819.  
  820. * Menu:
  821.  
  822. * Rule Variables::          Variables that say how a file is to be viewed.
  823. * Other Decode Variables::  Other decode variables.
  824. * Uuencoding and Posting::  Variables for customizing uuencoding.
  825.  
  826. 
  827. File: gnus,  Node: Rule Variables,  Next: Other Decode Variables,  Up: Decoding Variables
  828.  
  829. Rule Variables
  830. ..............
  831.  
  832.    Gnus uses "rule variables" to decide how to view a file.  All these
  833. variables are on the form
  834.  
  835.            (list '(regexp1 command2)
  836.                  '(regexp2 command2)
  837.                  ...)
  838.  
  839. `gnus-uu-user-view-rules'
  840.      This variable is consulted first when viewing files.  If you wish
  841.      to use, for instance, `sox' to convert an `.au' sound file, you
  842.      could say something like:
  843.                  (setq gnus-uu-user-view-rules
  844.                    (list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\")))
  845.  
  846. `gnus-uu-user-view-rules-end'
  847.      This variable is consulted if Gnus couldn't make any matches from
  848.      the user and default view rules.
  849.  
  850. `gnus-uu-user-archive-rules'
  851.      This variable can be used to say what commands should be used to
  852.      unpack archives.
  853.  
  854. 
  855. File: gnus,  Node: Other Decode Variables,  Next: Uuencoding and Posting,  Prev: Rule Variables,  Up: Decoding Variables
  856.  
  857. Other Decode Variables
  858. ......................
  859.  
  860. `gnus-uu-grabbed-file-functions'
  861.      All functions in this list will be called right each file has been
  862.      successfully decoded--so that you can move or view files right
  863.      away, and don't have to wait for all files to be decoded before
  864.      you can do anything.  Ready-made functions you can put in this
  865.      list are:
  866.  
  867.     `gnus-uu-grab-view'
  868.           View the file.
  869.  
  870.     `gnus-uu-grab-move'
  871.           Move the file (if you're using a saving function.)
  872.  
  873. `gnus-uu-ignore-files-by-name'
  874.      Files with name matching this regular expression won't be viewed.
  875.  
  876. `gnus-uu-ignore-files-by-type'
  877.      Files with a MIME type matching this variable won't be viewed.
  878.      Note that Gnus tries to guess what type the file is based on the
  879.      name.  `gnus-uu' is not a MIME package (yet), so this is slightly
  880.      kludgey.
  881.  
  882. `gnus-uu-tmp-dir'
  883.      Where `gnus-uu' does its work.
  884.  
  885. `gnus-uu-do-not-unpack-archives'
  886.      Non-`nil' means that `gnus-uu' won't peek inside archives looking
  887.      for files to display.
  888.  
  889. `gnus-uu-view-and-save'
  890.      Non-`nil' means that the user will always be asked to save a file
  891.      after viewing it.
  892.  
  893. `gnus-uu-ignore-default-view-rules'
  894.      Non-`nil' means that `gnus-uu' will ignore the default viewing
  895.      rules.
  896.  
  897. `gnus-uu-ignore-default-archive-rules'
  898.      Non-`nil' means that `gnus-uu' will ignore the default archive
  899.      unpacking commands.
  900.  
  901. `gnus-uu-kill-carriage-return'
  902.      Non-`nil' means that `gnus-uu' will strip all carriage returns
  903.      from articles.
  904.  
  905. `gnus-uu-unmark-articles-not-decoded'
  906.      Non-`nil' means that `gnus-uu' will mark articles that were
  907.      unsuccessfully decoded as unread.
  908.  
  909. `gnus-uu-correct-stripped-uucode'
  910.      Non-`nil' means that `gnus-uu' will *try* to fix uuencoded files
  911.      that have had trailing spaces deleted.
  912.  
  913. `gnus-uu-view-with-metamail'
  914.      Non-`nil' means that `gnus-uu' will ignore the viewing commands
  915.      defined by the rule variables and just fudge a MIME content type
  916.      based on the file name.  The result will be fed to `metamail' for
  917.      viewing.
  918.  
  919. `gnus-uu-save-in-digest'
  920.      Non-`nil' means that `gnus-uu', when asked to save without
  921.      decoding, will save in digests.  If this variable is `nil',
  922.      `gnus-uu' will just save everything in a file without any
  923.      embellishments.  The digesting almost conforms to RFC1153--no easy
  924.      way to specify any meaningful volume and issue numbers were found,
  925.      so I simply dropped them.
  926.  
  927. 
  928. File: gnus,  Node: Uuencoding and Posting,  Prev: Other Decode Variables,  Up: Decoding Variables
  929.  
  930. Uuencoding and Posting
  931. ......................
  932.  
  933. `gnus-uu-post-include-before-composing'
  934.      Non-`nil' means that `gnus-uu' will ask for a file to encode
  935.      before you compose the article.  If this variable is `t', you can
  936.      either include an encoded file with `C-c C-i' or have one included
  937.      for you when you post the article.
  938.  
  939. `gnus-uu-post-length'
  940.      Maximum length of an article.  The encoded file will be split into
  941.      how many articles it takes to post the entire file.
  942.  
  943. `gnus-uu-post-threaded'
  944.      Non-`nil' means that `gnus-uu' will post the encoded file in a
  945.      thread.  This may not be smart, as no other decoder I have seen
  946.      are able to follow threads when collecting uuencoded articles.
  947.      (Well, I have seen one package that does that--`gnus-uu', but
  948.      somehow, I don't think that counts...) Default is `nil'.
  949.  
  950. `gnus-uu-post-separate-description'
  951.      Non-`nil' means that the description will be posted in a separate
  952.      article.  The first article will typically be numbered (0/x).  If
  953.      this variable is `nil', the description the user enters will be
  954.      included at the beginning of the first article, which will be
  955.      numbered (1/x).  Default is `t'.
  956.  
  957. 
  958. File: gnus,  Node: Viewing Files,  Prev: Decoding Variables,  Up: Decoding Articles
  959.  
  960. Viewing Files
  961. -------------
  962.  
  963.    After decoding, if the file is some sort of archive, Gnus will
  964. attempt to unpack the archive and see if any of the files in the
  965. archive can be viewed.  For instance, if you have a gzipped tar file
  966. `pics.tar.gz' containing the files `pic1.jpg' and `pic2.gif', Gnus will
  967. uncompress and de-tar the main file, and then view the two pictures.
  968. This unpacking process is recursive, so if the archive contains archives
  969. of archives, it'll all be unpacked.
  970.  
  971.    Finally, Gnus will normally insert a "pseudo-article" for each
  972. extracted file into the summary buffer.  If you go to these "articles",
  973. you will be prompted for a command to run (usually Gnus will make a
  974. suggestion), and then the command will be run.
  975.  
  976.    If `gnus-view-pseudo-asynchronously' is `nil', Emacs will wait until
  977. the viewing is done before proceeding.
  978.  
  979.    If `gnus-view-pseudos' is `automatic', Gnus will not insert the
  980. pseudo-articles into the summary buffer, but view them immediately.  If
  981. this variable is `not-confirm', the user won't even be asked for a
  982. confirmation before viewing is done.
  983.  
  984.    If `gnus-view-pseudos-separately' is non-`nil', one pseudo-article
  985. will be created for each file to be viewed.  If `nil', all files that
  986. use the same viewing command will be given as a list of parameters to
  987. that command.
  988.  
  989.    If `gnus-insert-pseudo-articles' is non-`nil', insert
  990. pseudo-articles when decoding.  It is `t' by default.
  991.  
  992.    So; there you are, reading your *pseudo-articles* in your *virtual
  993. newsgroup* from the *virtual server*; and you think: Why isn't anything
  994. real anymore? How did we get here?
  995.  
  996. 
  997. File: gnus,  Node: Article Treatment,  Next: Summary Sorting,  Prev: Decoding Articles,  Up: The Summary Buffer
  998.  
  999. Article Treatment
  1000. =================
  1001.  
  1002.    Reading through this huge manual, you may have quite forgotten that
  1003. the object of newsreaders are to actually, like, read what people have
  1004. written.  Reading articles.  Unfortunately, people are quite bad at
  1005. writing, so there are tons of functions and variables to make reading
  1006. these articles easier.
  1007.  
  1008. * Menu:
  1009.  
  1010. * Article Highlighting::    You want to make the article look like fruit salad.
  1011. * Article Hiding::          You also want to make certain info go away.
  1012. * Article Washing::         Lots of way-neat functions to make life better.
  1013. * Article Buttons::         Click on URLs, Message-IDs, addresses and the like.
  1014. * Article Date::            Grumble, UT!
  1015.  
  1016. 
  1017. File: gnus,  Node: Article Highlighting,  Next: Article Hiding,  Up: Article Treatment
  1018.  
  1019. Article Highlighting
  1020. --------------------
  1021.  
  1022.    Not only do you want your article buffer to look like fruit salad,
  1023. but you want it to look like technicolor fruit salad.
  1024.  
  1025. `W H a'
  1026.      Highlight the current article (`gnus-article-highlight').
  1027.  
  1028. `W H h'
  1029.      Highlight the headers (`gnus-article-highlight-headers').  The
  1030.      highlighting will be done according to the `gnus-header-face-alist'
  1031.      variable, which is a list where each element has the form (REGEXP
  1032.      NAME CONTENT).  REGEXP is a regular expression for matching the
  1033.      header, NAME is the face used for highlighting the header name and
  1034.      CONTENT is the face for highlighting the header value.  The first
  1035.      match made will be used.  Note that REGEXP shouldn't have `^'
  1036.      prepended--Gnus will add one.
  1037.  
  1038. `W H c'
  1039.      Highlight cited text (`gnus-article-highlight-citation').
  1040.  
  1041.      Some variables to customize the citation highlights:
  1042.  
  1043.     `gnus-cite-parse-max-size'
  1044.           If the article size if bigger than this variable (which is
  1045.           25000 by default), no citation highlighting will be performed.
  1046.  
  1047.     `gnus-cite-prefix-regexp'
  1048.           Regexp matching the longest possible citation prefix on a
  1049.           line.
  1050.  
  1051.     `gnus-cite-max-prefix'
  1052.           Maximum possible length for a citation prefix (default 20).
  1053.  
  1054.     `gnus-cite-face-list'
  1055.           List of faces used for highlighting citations.  When there
  1056.           are citations from multiple articles in the same message,
  1057.           Gnus will try to give each citation from each article its own
  1058.           face.  This should make it easier to see who wrote what.
  1059.  
  1060.     `gnus-supercite-regexp'
  1061.           Regexp matching normal Supercite attribution lines.
  1062.  
  1063.     `gnus-supercite-secondary-regexp'
  1064.           Regexp matching mangled Supercite attribution lines.
  1065.  
  1066.     `gnus-cite-minimum-match-count'
  1067.           Minimum number of identical prefixes we have to see before we
  1068.           believe that it's a citation.
  1069.  
  1070.     `gnus-cite-attribution-prefix'
  1071.           Regexp matching the beginning of an attribution line.
  1072.  
  1073.     `gnus-cite-attribution-suffix'
  1074.           Regexp matching the end of an attribution line.
  1075.  
  1076.     `gnus-cite-attribution-face'
  1077.           Face used for attribution lines.  It is merged with the face
  1078.           for the cited text belonging to the attribution.
  1079.  
  1080. `W H s'
  1081.      Highlight the signature (`gnus-article-highlight-signature').
  1082.      Everything after `gnus-signature-separator' in an article will be
  1083.      considered a signature and will be highlighted with
  1084.      `gnus-signature-face', which is `italic' by default.
  1085.  
  1086. 
  1087. File: gnus,  Node: Article Hiding,  Next: Article Washing,  Prev: Article Highlighting,  Up: Article Treatment
  1088.  
  1089. Article Hiding
  1090. --------------
  1091.  
  1092.    Or rather, hiding certain things in each article.  There usually is
  1093. much too much cruft in most articles.
  1094.  
  1095. `W W a'
  1096.      Do maximum hiding on the summary buffer (`gnus-article-hide').
  1097.  
  1098. `W W h'
  1099.      Hide headers (`gnus-article-hide-headers').  *Note Hiding
  1100.      Headers::.
  1101.  
  1102. `W W b'
  1103.      Hide headers that aren't particularly interesting
  1104.      (`gnus-article-hide-boring-headers').  *Note Hiding Headers::.
  1105.  
  1106. `W W s'
  1107.      Hide signature (`gnus-article-hide-signature').
  1108.  
  1109. `W W p'
  1110.      Hide PGP signatures (`gnus-article-hide-pgp').
  1111.  
  1112. `W W c'
  1113.      Hide citation (`gnus-article-hide-citation').  Some variables for
  1114.      customizing the hiding:
  1115.  
  1116.     `gnus-cite-hide-percentage'
  1117.           If the cited text is of a bigger percentage than this
  1118.           variable (default 50), hide the cited text.
  1119.  
  1120.     `gnus-cite-hide-absolute'
  1121.           The cited text must be have at least this length (default 10)
  1122.           before it is hidden.
  1123.  
  1124.     `gnus-cited-text-button-line-format'
  1125.           Gnus adds buttons show where the cited text has been hidden,
  1126.           and to allow toggle hiding the text.  The format of the
  1127.           variable is specified by this format-like variable.  These
  1128.           specs are legal:
  1129.  
  1130.          `b'
  1131.                Start point of the hidden text.
  1132.  
  1133.          `e'
  1134.                End point of the hidden text.
  1135.  
  1136.          `l'
  1137.                Length of the hidden text.
  1138.  
  1139.     `gnus-cited-lines-visible'
  1140.           The number of lines at the beginning of the cited text to
  1141.           leave shown.
  1142.  
  1143. `W W C'
  1144.      Hide cited text in articles that aren't roots
  1145.      (`gnus-article-hide-citation-in-followups').  This isn't very
  1146.      useful as an interactive command, but might be a handy function to
  1147.      stick in `gnus-article-display-hook' (*note Customizing
  1148.      Articles::.).
  1149.  
  1150.    All these "hiding" commands are toggles, but if you give a negative
  1151. prefix to these commands, they will show what they have previously
  1152. hidden.  If you give a positive prefix, they will always hide.
  1153.  
  1154.    Also *note Article Highlighting::. for further variables for
  1155. citation customization.
  1156.  
  1157.    `gnus-signature-limit' provides a limit to what is considered a
  1158. signature.  If it is a number, no signature may not be longer (in
  1159. characters) than that number.  If it is a function, the function will be
  1160. called without any parameters, and if it returns `nil', there is no
  1161. signature in the buffer.  If it is a string, it will be used as a
  1162. regexp.  If it matches, the text in question is not a signature.
  1163.  
  1164. 
  1165. File: gnus,  Node: Article Washing,  Next: Article Buttons,  Prev: Article Hiding,  Up: Article Treatment
  1166.  
  1167. Article Washing
  1168. ---------------
  1169.  
  1170.    We call this "article washing" for a really good reason.  Namely, the
  1171. `A' key was taken, so we had to use the `W' key instead.
  1172.  
  1173.    "Washing" is defined by us as "changing something from something to
  1174. something else", but normally results in something looking better.
  1175. Cleaner, perhaps.
  1176.  
  1177. `W l'
  1178.      Remove page breaks from the current article
  1179.      (`gnus-summary-stop-page-breaking').
  1180.  
  1181. `W r'
  1182.      Do a Caesar rotate (rot13) on the article buffer
  1183.      (`gnus-summary-caesar-message').
  1184.  
  1185. `W t'
  1186.      Toggle whether to display all headers in the article buffer
  1187.      (`gnus-summary-toggle-header').
  1188.  
  1189. `W v'
  1190.      Toggle whether to display all headers in the article buffer
  1191.      permanently (`gnus-summary-verbose-header').
  1192.  
  1193. `W m'
  1194.      Toggle whether to run the article through MIME before displaying
  1195.      (`gnus-summary-toggle-mime').
  1196.  
  1197. `W o'
  1198.      Treat overstrike (`gnus-article-treat-overstrike').
  1199.  
  1200. `W w'
  1201.      Do word wrap (`gnus-article-fill-cited-article').
  1202.  
  1203. `W c'
  1204.      Remove CR (`gnus-article-remove-cr').
  1205.  
  1206. `W L'
  1207.      Remove all blank lines at the end of the article
  1208.      (`gnus-article-remove-trailing-blank-lines').
  1209.  
  1210. `W q'
  1211.      Treat quoted-printable (`gnus-article-de-quoted-unreadable').
  1212.  
  1213. `W f'
  1214.      Look for and display any X-Face headers
  1215.      (`gnus-article-display-x-face').  The command executed by this
  1216.      function is given by the `gnus-article-x-face-command' variable.
  1217.      If this variable is a string, this string will be executed in a
  1218.      sub-shell.  If it is a function, this function will be called with
  1219.      the face as the argument.  If the `gnus-article-x-face-too-ugly'
  1220.      (which is a regexp) matches the `From' header, the face will not
  1221.      be shown.  The default action under Emacs is to fork off an `xv'
  1222.      to view the face; under XEmacs the default action is to display
  1223.      the face before the `From' header.  (It's nicer if XEmacs has been
  1224.      compiled with X-Face support - that will make display somewhat
  1225.      faster.  If there's no native X-Face support, Gnus will try to
  1226.      convert the `X-Face' header using external programs from the
  1227.      `pbmplus' package and friends.)  If you want to have this function
  1228.      in the display hook, it should probably come last.
  1229.  
  1230. `W b'
  1231.      Add clickable buttons to the article (`gnus-article-add-buttons').
  1232.  
  1233. `W B'
  1234.      Add clickable buttons to the article headers
  1235.      (`gnus-article-add-buttons-to-head').
  1236.  
  1237.